/**
 * 权限工具类 - 完全模仿MyApplication2的CommunalMethodUtil权限逻辑
 * 根据用户积分等级判断免费发布活动、加好友等权限
 */

const storage = require('./storage.js');

// 权限控制变量 - 模仿MyApplication2的静态变量
let canAddFriend = false;           // 是否可以免费加好友
let canAddFriendNumber = 0;         // 当天免费加好友次数
let canPublishActivity = false;     // 是否可以免费发布活动
let canPublishActivityNumber = 0;   // 当天免费发布活动次数
let publishActivityCost = 0;        // 🔥 付费发布时每次消耗的积分
let addFriendCost = 0;              // 🔥 新增：付费加好友时每次消耗的积分

// 存储键名
const STORAGE_KEYS = {
  DATE: 'permission_date',                    // 日期
  PUBLISH_COUNT: 'publish_activity_count',    // 发布活动次数
  ADD_FRIEND_COUNT: 'add_friend_count'        // 加好友次数
};

/**
 * 🎯 根据用户积分设置权限 - 新规则：低等级可付费发布
 * @param {number} userPoints - 用户积分
 */
function accordingToUserPointsForPermission(userPoints) {
  console.log('🎯 =============== 权限计算开始 ===============');
  console.log('💰 当前用户积分:', userPoints);
  
  if (0 <= userPoints && userPoints < 100) {
    // 🎯 0~99积分：追随者等级 - 可付费发布（每次10积分）、可付费加好友（每次5积分）
    canAddFriend = false;
    canAddFriendNumber = 0;
    canPublishActivity = false;  // 无免费权限
    canPublishActivityNumber = 0;
    publishActivityCost = 10;  // 🔥 每次发布消耗10积分
    addFriendCost = 10;  // 🔥 每次加好友消耗10积分
    console.log('🏷️ 用户等级: 追随者 (0~99积分)');
    console.log('💰 加好友权限: 可付费加好友（每次消耗10积分）');
    console.log('💰 发布活动权限: 可付费发布（每次消耗10积分）');
    
  } else if (100 <= userPoints && userPoints < 300) {
    // 🎯 100~299积分：守护者等级 - 加好友1次/天（超出3积分/次），可付费发布（每次5积分）
    canAddFriend = true;
    canAddFriendNumber = 1;
    canPublishActivity = false;  // 无免费权限
    canPublishActivityNumber = 0;
    publishActivityCost = 5;  // 🔥 每次发布消耗5积分
    addFriendCost = 3;  // 🔥 免费次数用完后，每次加好友消耗3积分
    console.log('🏷️ 用户等级: 守护者 (100~299积分)');
    console.log('✅ 加好友权限: 1次/天（免费），超出后3积分/次');
    console.log('💰 发布活动权限: 可付费发布（每次消耗5积分）');
    
  } else if (300 <= userPoints && userPoints < 600) {
    // 🎯 300~599积分：创造者等级 - 加好友3次/天，免费发布1次/天
    canAddFriend = true;
    canAddFriendNumber = 3;
    canPublishActivity = true;  // 有免费权限
    canPublishActivityNumber = 1;
    publishActivityCost = 0;  // 🔥 免费时不消耗积分
    addFriendCost = 3;  // 🔥 免费次数用完后，每次加好友消耗3积分
    console.log('🏷️ 用户等级: 创造者 (300~599积分)');
    console.log('✅ 加好友权限: 3次/天（免费），超出后3积分/次');
    console.log('🎉 发布活动权限: 免费1次/天，超出后每次消耗5积分');
    
  } else if (600 <= userPoints && userPoints < 1200) {
    // 🎯 600~1199积分：真神等级 - 加好友5次/天，免费发布2次/天
    canAddFriend = true;
    canAddFriendNumber = 5;
    canPublishActivity = true;  // 有免费权限
    canPublishActivityNumber = 2;
    publishActivityCost = 0;  // 🔥 免费时不消耗积分
    addFriendCost = 3;  // 🔥 免费次数用完后，每次加好友消耗3积分
    console.log('🏷️ 用户等级: 真神 (600~1199积分)');
    console.log('✅ 加好友权限: 5次/天（免费），超出后3积分/次');
    console.log('🎉 发布活动权限: 免费2次/天，超出后每次消耗5积分');
    
  } else {
    // 🎯 1200+积分：一言九鼎等级 - 加好友10次/天，免费发布5次/天
    canAddFriend = true;
    canAddFriendNumber = 10;
    canPublishActivity = true;  // 有免费权限
    canPublishActivityNumber = 5;
    publishActivityCost = 0;  // 🔥 免费时不消耗积分
    addFriendCost = 3;  // 🔥 免费次数用完后，每次加好友消耗3积分
    console.log('🏷️ 用户等级: 一言九鼎 (1200+积分)');
    console.log('✅ 加好友权限: 10次/天（免费），超出后3积分/次');
    console.log('🎉 发布活动权限: 免费5次/天，超出后每次消耗5积分');
  }
  
  console.log('🎯 =============== 权限计算完成 ===============');
}

/**
 * 🔄 初始化权限系统 - 在应用启动时调用
 */
function initializePermissions() {
  const userInfo = storage.getUserInfo();
  if (userInfo && userInfo.userPoints !== undefined) {
    accordingToUserPointsForPermission(userInfo.userPoints);
  }
}

/**
 * 💰 更新用户积分并重新计算权限 - 模仿MyApplication2的changeUserPoints
 * @param {number} pointsChange - 积分变化量
 */
function changeUserPoints(pointsChange) {
  const userInfo = storage.getUserInfo();
  if (userInfo) {
    const newPoints = (userInfo.userPoints || 0) + pointsChange;
    
    // 更新用户积分
    storage.updateUserInfo({ userPoints: newPoints });
    
    // 重新计算权限
    accordingToUserPointsForPermission(newPoints);
    
    console.log('💰 =============== 积分变化处理 ===============');
    console.log('📈 积分变化:', pointsChange > 0 ? '+' + pointsChange : pointsChange);
    console.log('💰 新积分总数:', newPoints);
    console.log('🔄 权限已重新计算');
  }
}

/**
 * 🚀 计算发布活动的free参数 - 🔥 微信免费开放版本
 * @returns {number} 0=付费发布, 1=免费发布
 * @throws {Error} 积分不足时抛出异常
 */
function calculatePublishActivityFree() {
  console.log('🚀🚀🚀 =============== 微信免费模式：发布活动完全免费 =============== 🚀🚀🚀');
  console.log('✅✅✅ 微信小程序免费开放，不扣除任何积分，直接返回 free=1 ✅✅✅');
  return 1; // 🔥 直接返回免费，不检查积分
  
  /* 🔥 原积分限制逻辑已注释（微信免费开放）
  const userInfo = storage.getUserInfo();
  const userPoints = userInfo ? userInfo.userPoints : 0;
  
  console.log('💰 用户当前积分:', userPoints);
  console.log('🎯 是否有免费权限:', canPublishActivity);
  console.log('🎯 每日免费限额:', canPublishActivityNumber);
  console.log('💳 付费发布消耗:', publishActivityCost, '积分');
  
  // 第一步：检查是否有免费发布权限
  if (canPublishActivity && canPublishActivityNumber > 0) {
    const today = getTodayString();
    const storedDate = wx.getStorageSync(STORAGE_KEYS.DATE) || '';
    const todayPublishCount = storedDate === today 
      ? (wx.getStorageSync(STORAGE_KEYS.PUBLISH_COUNT) || 0) 
      : 0;
    
    console.log('📅 今日日期:', today);
    console.log('📊 今日已发布次数:', todayPublishCount);
    
    // 还有免费次数
    if (todayPublishCount < canPublishActivityNumber) {
      console.log('✅ 今日还有免费次数，返回 free = 1 (免费发布)');
      return 1; // 免费
    }
    
    console.log('⚠️ 今日免费次数已用完');
  } else {
    console.log('⚠️ 当前等级无免费发布权限');
  }
  
  // 第二步：检查是否有足够积分付费发布
  if (publishActivityCost > 0) {
    console.log('💰 检查积分是否足够付费发布...');
    
    if (userPoints >= publishActivityCost) {
      console.log(`✅ 积分充足（${userPoints} >= ${publishActivityCost}），返回 free = 0 (付费发布)`);
      console.log(`📌 后端将扣除 ${publishActivityCost} 积分`);
      return 0; // 付费发布
    } else {
      console.log(`❌ 积分不足（${userPoints} < ${publishActivityCost}）`);
      throw new Error(`积分不足，需要${publishActivityCost}积分才能发布活动`);
    }
  }
  
  // 第三步：300+积分用户，免费次数用完后可付费发布（每次5积分）
  if (canPublishActivity && publishActivityCost === 0) {
    // 创造者及以上等级，免费次数用完后，按5积分/次收费
    const fallbackCost = 5;
    if (userPoints >= fallbackCost) {
      console.log(`✅ 免费次数已用完，使用备选付费模式（${fallbackCost}积分/次）`);
      return 0; // 付费发布
    } else {
      console.log(`❌ 积分不足（${userPoints} < ${fallbackCost}）`);
      throw new Error(`免费次数已用完，需要${fallbackCost}积分才能继续发布`);
    }
  }
  
  // 异常情况
  console.error('❌ 未知错误：无法计算发布权限');
  throw new Error('系统错误，请稍后重试');
  */
}

/**
 * 🤝 计算加好友的free参数 - 🔥 微信免费开放版本
 * @returns {number} 0=付费加好友, 1=免费加好友
 * @throws {Error} 积分不足时抛出异常
 */
function calculateAddFriendFree() {
  console.log('🤝🤝🤝 =============== 微信免费模式：加好友完全免费 =============== 🤝🤝🤝');
  console.log('✅✅✅ 微信小程序免费开放，不扣除任何积分，直接返回 free=1 ✅✅✅');
  return 1; // 🔥 直接返回免费，不检查积分
  
  /* 🔥 原积分限制逻辑已注释（微信免费开放）
  const userInfo = storage.getUserInfo();
  const userPoints = userInfo ? userInfo.userPoints : 0;
  
  // 🔥 保护机制：如果权限未初始化（addFriendCost和canAddFriend都是默认值），先初始化
  if (canAddFriend === false && canAddFriendNumber === 0 && addFriendCost === 0) {
    console.log('⚠️ 检测到权限未初始化，自动初始化权限系统...');
    if (userInfo && userInfo.userPoints !== undefined) {
      accordingToUserPointsForPermission(userInfo.userPoints);
      console.log('✅ 权限系统已自动初始化');
    }
  }
  
  console.log('💰 用户当前积分:', userPoints);
  console.log('🎯 是否有免费权限:', canAddFriend);
  console.log('🎯 每日免费限额:', canAddFriendNumber);
  console.log('💳 付费加好友消耗:', addFriendCost, '积分');
  
  // 第一步：检查是否有免费加好友权限
  if (canAddFriend && canAddFriendNumber > 0) {
    const today = getTodayString();
    const storedDate = wx.getStorageSync(STORAGE_KEYS.DATE) || '';
    const todayAddFriendCount = storedDate === today 
      ? (wx.getStorageSync(STORAGE_KEYS.ADD_FRIEND_COUNT) || 0) 
      : 0;
    
    console.log('📅 今日日期:', today);
    console.log('📊 今日已加好友次数:', todayAddFriendCount);
    
    // 还有免费次数
    if (todayAddFriendCount < canAddFriendNumber) {
      console.log('✅ 今日还有免费次数，返回 free = 1 (免费加好友)');
      return 1; // 免费
    }
    
    console.log('⚠️ 今日免费次数已用完');
  } else {
    console.log('⚠️ 当前等级无免费加好友权限');
  }
  
  // 第二步：检查是否有足够积分付费加好友
  if (addFriendCost > 0) {
    console.log('💰 检查积分是否足够付费加好友...');
    
    if (userPoints >= addFriendCost) {
      console.log(`✅ 积分充足（${userPoints} >= ${addFriendCost}），返回 free = 0 (付费加好友)`);
      console.log(`📌 后端将扣除 ${addFriendCost} 积分`);
      return 0; // 付费加好友
    } else {
      console.log(`❌ 积分不足（${userPoints} < ${addFriendCost}）`);
      throw new Error(`积分不足，需要${addFriendCost}积分才能加好友`);
    }
  }
  
  // 第三步：高等级用户（100+积分），免费次数用完后可付费加好友（每次3积分）
  if (canAddFriend && addFriendCost === 0) {
    // 守护者及以上等级，免费次数用完后，按3积分/次收费
    const fallbackCost = 3;
    if (userPoints >= fallbackCost) {
      console.log(`✅ 免费次数已用完，使用备选付费模式（${fallbackCost}积分/次）`);
      return 0; // 付费加好友
    } else {
      console.log(`❌ 积分不足（${userPoints} < ${fallbackCost}）`);
      throw new Error(`免费次数已用完，需要${fallbackCost}积分才能继续加好友`);
    }
  }
  
  // 异常情况
  console.error('❌ 未知错误：无法计算加好友权限');
  console.error('   当前状态: canAddFriend=', canAddFriend, 'addFriendCost=', addFriendCost);
  throw new Error('系统错误，请稍后重试');
  */
}

/**
 * 📈 增加发布活动次数统计
 */
function incrementPublishActivityCount() {
  const today = getTodayString();
  const storedDate = wx.getStorageSync(STORAGE_KEYS.DATE) || '';
  
  if (storedDate !== today) {
    // 🔥 新的一天，重置所有计数器（修复bug）
    wx.setStorageSync(STORAGE_KEYS.DATE, today);
    wx.setStorageSync(STORAGE_KEYS.PUBLISH_COUNT, 1);
    wx.setStorageSync(STORAGE_KEYS.ADD_FRIEND_COUNT, 0); // 🔥 同时重置加好友计数
    console.log('📅 新的一天开始，所有计数器已重置，发布活动计数=1，加好友计数=0');
  } else {
    // 同一天，增加计数
    const currentCount = wx.getStorageSync(STORAGE_KEYS.PUBLISH_COUNT) || 0;
    wx.setStorageSync(STORAGE_KEYS.PUBLISH_COUNT, currentCount + 1);
    console.log('📈 发布活动计数增加至:', currentCount + 1);
  }
}

/**
 * 📈 增加加好友次数统计
 */
function incrementAddFriendCount() {
  const today = getTodayString();
  const storedDate = wx.getStorageSync(STORAGE_KEYS.DATE) || '';
  
  if (storedDate !== today) {
    // 🔥 新的一天，重置所有计数器（修复bug）
    wx.setStorageSync(STORAGE_KEYS.DATE, today);
    wx.setStorageSync(STORAGE_KEYS.ADD_FRIEND_COUNT, 1);
    wx.setStorageSync(STORAGE_KEYS.PUBLISH_COUNT, 0); // 🔥 同时重置发布活动计数
    console.log('📅 新的一天开始，所有计数器已重置，加好友计数=1，发布活动计数=0');
  } else {
    // 同一天，增加计数
    const currentCount = wx.getStorageSync(STORAGE_KEYS.ADD_FRIEND_COUNT) || 0;
    wx.setStorageSync(STORAGE_KEYS.ADD_FRIEND_COUNT, currentCount + 1);
    console.log('📈 加好友计数增加至:', currentCount + 1);
  }
}

/**
 * 📅 获取今日日期字符串 (格式: yyyy-MM-dd)
 * @returns {string}
 */
function getTodayString() {
  const now = new Date();
  const year = now.getFullYear();
  const month = String(now.getMonth() + 1).padStart(2, '0'); // 🔥 使用标准的padStart方法
  const day = String(now.getDate()).padStart(2, '0'); // 🔥 使用标准的padStart方法
  return `${year}-${month}-${day}`;
}

/**
 * 📊 获取今日剩余免费次数信息
 * @returns {Object}
 */
function getTodayRemainingCounts() {
  const today = getTodayString();
  const storedDate = wx.getStorageSync(STORAGE_KEYS.DATE) || '';
  
  const todayPublishCount = storedDate === today 
    ? (wx.getStorageSync(STORAGE_KEYS.PUBLISH_COUNT) || 0) 
    : 0;
  const todayAddFriendCount = storedDate === today 
    ? (wx.getStorageSync(STORAGE_KEYS.ADD_FRIEND_COUNT) || 0) 
    : 0;
  
  return {
    publishActivity: Math.max(0, canPublishActivityNumber - todayPublishCount),
    addFriend: Math.max(0, canAddFriendNumber - todayAddFriendCount)
  };
}

/**
 * 🔄 强制刷新权限（在用户积分变化后调用）
 */
function refreshPermissions() {
  const userInfo = storage.getUserInfo();
  if (userInfo && userInfo.userPoints !== undefined) {
    accordingToUserPointsForPermission(userInfo.userPoints);
  }
}

/**
 * ❌ 显示积分不足的提示
 */
function showNoPermissionMessage() {
  wx.showToast({
    title: '积分不足，请前往充值',
    icon: 'none',
    duration: 2000
  });
}

/**
 * 📊 获取当前发布活动的积分消耗
 * @returns {number} 消耗的积分数
 */
function getPublishActivityCost() {
  return publishActivityCost;
}

/**
 * 📊 获取当前加好友的积分消耗
 * @returns {number} 消耗的积分数
 */
function getAddFriendCost() {
  return addFriendCost;
}

/**
 * ✅ 检查用户是否可以发布活动（用于UI预判断） - 🔥 微信免费开放版本
 * @returns {Object} { canPublish: boolean, message: string, cost: number }
 */
function checkCanPublishActivity() {
  // 🔥 微信免费开放：直接返回可以免费发布
  return {
    canPublish: true,
    message: '微信免费开放，无限制发布',
    cost: 0,
    isFree: true
  };
  
  /* 🔥 原积分限制逻辑已注释（微信免费开放）
  const userInfo = storage.getUserInfo();
  const userPoints = userInfo ? userInfo.userPoints : 0;
  
  // 检查是否有免费次数
  if (canPublishActivity && canPublishActivityNumber > 0) {
    const today = getTodayString();
    const storedDate = wx.getStorageSync(STORAGE_KEYS.DATE) || '';
    const todayPublishCount = storedDate === today 
      ? (wx.getStorageSync(STORAGE_KEYS.PUBLISH_COUNT) || 0) 
      : 0;
    
    if (todayPublishCount < canPublishActivityNumber) {
      return {
        canPublish: true,
        message: `今日还可免费发布 ${canPublishActivityNumber - todayPublishCount} 次`,
        cost: 0,
        isFree: true
      };
    }
  }
  
  // 检查付费发布
  const cost = publishActivityCost > 0 ? publishActivityCost : 5;
  
  if (userPoints >= cost) {
    return {
      canPublish: true,
      message: `发布将消耗 ${cost} 积分`,
      cost: cost,
      isFree: false
    };
  } else {
    return {
      canPublish: false,
      message: `积分不足，需要 ${cost} 积分`,
      cost: cost,
      isFree: false
    };
  }
  */
}

/**
 * ✅ 检查用户是否可以加好友（用于UI预判断） - 🔥 微信免费开放版本
 * @returns {Object} { canAdd: boolean, message: string, cost: number }
 */
function checkCanAddFriend() {
  // 🔥 微信免费开放：直接返回可以免费加好友
  return {
    canAdd: true,
    message: '微信免费开放，无限制加好友',
    cost: 0,
    isFree: true
  };
  
  /* 🔥 原积分限制逻辑已注释（微信免费开放）
  const userInfo = storage.getUserInfo();
  const userPoints = userInfo ? userInfo.userPoints : 0;
  
  // 检查是否有免费次数
  if (canAddFriend && canAddFriendNumber > 0) {
    const today = getTodayString();
    const storedDate = wx.getStorageSync(STORAGE_KEYS.DATE) || '';
    const todayAddFriendCount = storedDate === today 
      ? (wx.getStorageSync(STORAGE_KEYS.ADD_FRIEND_COUNT) || 0) 
      : 0;
    
    if (todayAddFriendCount < canAddFriendNumber) {
      return {
        canAdd: true,
        message: `今日还可免费加好友 ${canAddFriendNumber - todayAddFriendCount} 次`,
        cost: 0,
        isFree: true
      };
    }
  }
  
  // 检查付费加好友
  const cost = addFriendCost;
  
  if (userPoints >= cost) {
    return {
      canAdd: true,
      message: `加好友将消耗 ${cost} 积分`,
      cost: cost,
      isFree: false
    };
  } else {
    return {
      canAdd: false,
      message: `积分不足，需要 ${cost} 积分`,
      cost: cost,
      isFree: false
    };
  }
  */
}

module.exports = {
  accordingToUserPointsForPermission,
  initializePermissions,
  changeUserPoints,
  calculatePublishActivityFree,
  calculateAddFriendFree,
  incrementPublishActivityCount,
  incrementAddFriendCount,
  getTodayRemainingCounts,
  refreshPermissions,
  showNoPermissionMessage,
  getPublishActivityCost,        // 🔥 新增
  getAddFriendCost,              // 🔥 新增
  checkCanPublishActivity,       // 🔥 新增
  checkCanAddFriend              // 🔥 新增
};

